package com.ethink.warehouse.facade.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ethink.warehouse.api.MateInventoryFacade;
import com.ethink.warehouse.api.enums.MateInventoryAdjustLogAdjustTypeEnum;
import com.ethink.warehouse.api.info.MateInventoryDetailInfo;
import com.ethink.warehouse.api.request.*;
import com.ethink.warehouse.api.response.MateInventoryOutResponse;
import com.ethink.warehouse.api.response.MateInventoryQueryBySkuResponse;
import com.ethink.warehouse.common.mapper.MateInventoryMapper;
import com.ethink.warehouse.common.model.MateInventoryAutoAdjustItemModel;
import com.ethink.warehouse.common.model.MateInventoryAutoAdjustModel;
import com.ethink.warehouse.manager.MateInventoryAdjustManager;
import com.ethink.warehouse.manager.MateInventoryManager;
import com.ethink.warehouse.service.MateInventoryService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 仓库库存 Facade接口实现
 *
 * @author default
 * @date 2022-11-08
 */
@RestController
@Slf4j
@RequestMapping("warehouse-service/facade/v1/mateInventory")
public class MateInventoryFacadeImpl implements MateInventoryFacade {

    @Autowired
    private MateInventoryService mateInventoryService;

    @Autowired
    private MateInventoryMapper mateInventoryMapper;

    @Autowired
    private MateInventoryManager mateInventoryManager;

    @Autowired
    private MateInventoryAdjustManager mateInventoryAdjustManager;

    @Override
    public Page<MateInventoryDetailInfo> queryMateInventory(MateInventoryQueryRequest request) {
        return mateInventoryService.queryMateInventory(request);
    }

    @Override
    public Page<MateInventoryQueryBySkuResponse> queryMateInventoryBySku(MateInventoryQueryBySkuRequest request) {
        return mateInventoryService.queryMateInventoryBySku(request);
    }

    @Override
    public List<MateInventoryDetailInfo> listMateInventoryByIdList(List<Long> idList) {
        if (CollectionUtils.isEmpty(idList)) {
            return new ArrayList<>();
        }
        return mateInventoryMapper.listMateInventoryByIdList(idList);
    }

    @Override
    public List<MateInventoryDetailInfo> listMateInventoryByKeyList(List<MateInventoryQueryKeyInfo> keyList) {
        if (CollectionUtils.isEmpty(keyList)) {
            return new ArrayList<>();
        }
        if (StringUtils.isBlank(keyList.get(0).getPurchaseCode())) {
            return mateInventoryMapper.listByNoPurchaseCodeKeyList(keyList);
        }
        return mateInventoryMapper.listMateInventoryByKeyList(keyList);
    }

    @Override
    public List<MateInventoryDetailInfo> listMateInventoryByMateSkuList(List<MateInventoryQueryKeyInfo> mateSkuList) {
        if (CollectionUtils.isEmpty(mateSkuList)) {
            return new ArrayList<>();
        }
        return mateInventoryMapper.listMateInventoryByMateSkuList(mateSkuList);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void lockMateInventory(List<MateInventoryLockLogAddRequest> requests) {
        mateInventoryManager.lockMateInventory(requests);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void releaseLockMateInventory(List<MateInventoryLockLogAddRequest> requests) {
        mateInventoryManager.releaseLockMateInventory(requests);
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public MateInventoryOutResponse outMateInventory(MateInventoryOutRequest request) {
        return mateInventoryManager.outMateInventory(request);
    }

    @Override
    public List<MateInventoryDetailInfo> listMateInventoryByPurchaseDetailOrderNoList(List<String> purchaseDetailOrderNoList) {
        return mateInventoryMapper.listMateInventoryByPurchaseDetailOrderNoList(purchaseDetailOrderNoList);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void addMateInventoryOrderAddT51OrT91(List<MateInventoryOrderAddT51OrT91Request> requests) {
        Map<String, List<MateInventoryOrderAddT51OrT91Request>> groupMap = requests.stream()
                .collect(Collectors.groupingBy(MateInventoryOrderAddT51OrT91Request::getSubWarehouseCode));
        // 按仓库分组处理
        for (Map.Entry<String, List<MateInventoryOrderAddT51OrT91Request>> entry : groupMap.entrySet()) {
            List<MateInventoryAutoAdjustItemModel> totalItemModels = new ArrayList<>();
            for (MateInventoryOrderAddT51OrT91Request request : entry.getValue()) {
                List<MateInventoryAutoAdjustItemModel> itemModels = mateInventoryManager.t51OrT91(request);
                if (CollectionUtils.isNotEmpty(itemModels)) {
                    totalItemModels.addAll(itemModels);
                }
            }
            if (totalItemModels.size() > 0) {
                MateInventoryAutoAdjustModel model = new MateInventoryAutoAdjustModel();
                model.setSubWarehouseCode(entry.getKey());
                model.setAdjustType(MateInventoryAdjustLogAdjustTypeEnum.T2.getIntValue());
                model.setAdjustReason("售后单自动矫正");
                model.setItems(totalItemModels);
                mateInventoryAdjustManager.autoAdjust(model);
            }
        }
    }

    @Override
    public Integer countByMateSkuList(List<String> mateSkuList) {
        if (CollectionUtils.isEmpty(mateSkuList)) {
            return 0;
        }
        return mateInventoryMapper.countByMateSkuList(mateSkuList);
    }

    @Override
    public MateInventoryQueryBySkuResponse queryMateInventoryBySkuSum(MateInventoryQueryBySkuRequest request) {
        return mateInventoryService.queryMateInventoryBySkuSum(request);
    }

    @Override
    public MateInventoryDetailInfo queryMateInventorySum(MateInventoryQueryRequest request) {
        return mateInventoryMapper.queryMateInventorySum(request);
    }
}